juce/source/extras/the jucer/src/ui/jucer_ComponentLayoutEditor.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../jucer_Headers.h"
  27 #include "jucer_ComponentLayoutEditor.h"
  28 #include "../model/jucer_ObjectTypes.h"
  29 #include "../model/components/jucer_JucerComponentHandler.h"
  30
  31 //==============================================================================
  32 class SubComponentHolderComp    : public Component
  33 {
  34 public:
  35     SubComponentHolderComp (JucerDocument& document_,
  36                             SnapGridPainter& grid_)
  37        : document (document_),
  38          grid (grid_),
  39          dontFillBackground (false)
  40     {
  41         setInterceptsMouseClicks (false, false);
  42         setWantsKeyboardFocus (false);
  43         setFocusContainer (true);
  44     }
  45
  46     ~SubComponentHolderComp()
  47     {
  48     }
  49
  50     void paint (Graphics& g)
  51     {
  52         if (! dontFillBackground)
  53         {
  54             PaintRoutine* const background = document.getPaintRoutine (0);
  55
  56             if (background != 0)
  57             {
  58                 background->fillWithBackground (g, false);
  59                 background->drawElements (g, Rectangle<int> (0, 0, getWidth(), getHeight()));
  60             }
  61
  62             grid.draw (g, background);
  63         }
  64     }
  65
  66     void resized()
  67     {
  68         if (! getBounds().isEmpty())
  69         {
  70             int numTimesToTry = 10;
  71
  72             while (--numTimesToTry >= 0)
  73             {
  74                 bool anyCompsMoved = false;
  75
  76                 for (int i = 0; i < getNumChildComponents(); ++i)
  77                 {
  78                     Component* comp = getChildComponent (i);
  79                     ComponentTypeHandler* const type = ComponentTypeHandler::getHandlerFor (*comp);
  80
  81                     if (type != 0)
  82                     {
  83                         const Rectangle<int> newBounds (type->getComponentPosition (comp)
  84                                                           .getRectangle (Rectangle<int> (0, 0, getWidth(), getHeight()),
  85                                                                          document.getComponentLayout()));
  86
  87                         anyCompsMoved = anyCompsMoved || (comp->getBounds() != newBounds);
  88                         comp->setBounds (newBounds);
  89                     }
  90                 }
  91
  92                 // repeat this loop until they've all stopped shuffling (might require a few
  93                 // loops for all the relative positioned comps to settle down)
  94                 if (! anyCompsMoved)
  95                     break;
  96             }
  97         }
  98     }
  99
 100     void moved()
 101     {
 102         ((ComponentLayoutEditor*) getParentComponent())->updateOverlayPositions();
 103     }
 104
 105     JucerDocument& document;
 106     SnapGridPainter& grid;
 107     bool dontFillBackground;
 108 };
 109
 110 //==============================================================================
 111 ComponentLayoutEditor::ComponentLayoutEditor (JucerDocument& document_, ComponentLayout& layout_)
 112     : document (document_),
 113       layout (layout_),
 114       firstResize (true)
 115 {
 116     setWantsKeyboardFocus (true);
 117
 118     addAndMakeVisible (subCompHolder = new SubComponentHolderComp (document, grid));
 119
 120     refreshAllComponents();
 121
 122     setSize (document.getInitialWidth(), document.getInitialHeight());
 123 }
 124
 125 ComponentLayoutEditor::~ComponentLayoutEditor()
 126 {
 127     document.removeChangeListener (this);
 128
 129     removeChildComponent (&lassoComp);
 130     deleteAllChildren();
 131 }
 132
 133 //==============================================================================
 134 void ComponentLayoutEditor::visibilityChanged()
 135 {
 136     document.getUndoManager().beginNewTransaction();
 137
 138     if (isVisible())
 139     {
 140         refreshAllComponents();
 141         document.addChangeListener (this);
 142     }
 143     else
 144     {
 145         document.removeChangeListener (this);
 146     }
 147 }
 148
 149 void ComponentLayoutEditor::changeListenerCallback (ChangeBroadcaster*)
 150 {
 151     refreshAllComponents();
 152 }
 153
 154 void ComponentLayoutEditor::paint (Graphics& g)
 155 {
 156 }
 157
 158 void ComponentLayoutEditor::resized()
 159 {
 160     if (firstResize && getWidth() > 0 && getHeight() > 0)
 161     {
 162         firstResize = false;
 163         refreshAllComponents();
 164     }
 165
 166     subCompHolder->setBounds (getComponentArea());
 167     updateOverlayPositions();
 168 }
 169
 170 const Rectangle<int> ComponentLayoutEditor::getComponentArea() const
 171 {
 172     if (document.isFixedSize())
 173     {
 174         return Rectangle<int> ((getWidth() - document.getInitialWidth()) / 2,
 175                                (getHeight() - document.getInitialHeight()) / 2,
 176                                document.getInitialWidth(),
 177                                document.getInitialHeight());
 178     }
 179     else
 180     {
 181         return Rectangle<int> (editorEdgeGap, editorEdgeGap,
 182                                getWidth() - editorEdgeGap * 2,
 183                                getHeight() - editorEdgeGap * 2);
 184     }
 185 }
 186
 187 const Image ComponentLayoutEditor::createComponentLayerSnapshot() const
 188 {
 189     ((SubComponentHolderComp*) subCompHolder)->dontFillBackground = true;
 190     Image im = subCompHolder->createComponentSnapshot (Rectangle<int> (0, 0, subCompHolder->getWidth(), subCompHolder->getHeight()));
 191     ((SubComponentHolderComp*) subCompHolder)->dontFillBackground = false;
 192
 193     return im;
 194 }
 195
 196 void ComponentLayoutEditor::updateOverlayPositions()
 197 {
 198     for (int i = getNumChildComponents(); --i >= 0;)
 199     {
 200         ComponentOverlayComponent* const overlay = dynamic_cast <ComponentOverlayComponent*> (getChildComponent (i));
 201
 202         if (overlay != 0)
 203             overlay->updateBoundsToMatchTarget();
 204     }
 205 }
 206
 207 void ComponentLayoutEditor::refreshAllComponents()
 208 {
 209     int i;
 210     for (i = getNumChildComponents(); --i >= 0;)
 211     {
 212         ComponentOverlayComponent* const overlay = dynamic_cast <ComponentOverlayComponent*> (getChildComponent (i));
 213
 214         if (overlay != 0 && ! layout.containsComponent (overlay->target))
 215             delete overlay;
 216     }
 217
 218     for (i = subCompHolder->getNumChildComponents(); --i >= 0;)
 219     {
 220         Component* const comp = subCompHolder->getChildComponent (i);
 221
 222         if (! layout.containsComponent (comp))
 223             subCompHolder->removeChildComponent (comp);
 224     }
 225
 226     Component* lastComp = 0;
 227     Component* lastOverlay = 0;
 228
 229     for (i = layout.getNumComponents(); --i >= 0;)
 230     {
 231         Component* const c = layout.getComponent (i);
 232         ComponentOverlayComponent* overlay = getOverlayCompFor (c);
 233
 234         bool isNewOverlay = false;
 235
 236         if (overlay == 0)
 237         {
 238             ComponentTypeHandler* const handler = ComponentTypeHandler::getHandlerFor (*c);
 239             jassert (handler != 0);
 240
 241             overlay = handler->createOverlayComponent (c, layout);
 242
 243             addAndMakeVisible (overlay);
 244             isNewOverlay = true;
 245         }
 246
 247         if (lastOverlay != 0)
 248             overlay->toBehind (lastOverlay);
 249         else
 250             overlay->toFront (false);
 251
 252         lastOverlay = overlay;
 253
 254         subCompHolder->addAndMakeVisible (c);
 255
 256         if (lastComp != 0)
 257             c->toBehind (lastComp);
 258         else
 259             c->toFront (false);
 260
 261         lastComp = c;
 262
 263         c->setWantsKeyboardFocus (false);
 264         c->setFocusContainer (true);
 265
 266         if (isNewOverlay)
 267             overlay->updateBoundsToMatchTarget();
 268     }
 269
 270     if (grid.updateFromDesign (document))
 271         subCompHolder->repaint();
 272
 273     subCompHolder->setBounds (getComponentArea());
 274     subCompHolder->resized();
 275 }
 276
 277 void ComponentLayoutEditor::mouseDown (const MouseEvent& e)
 278 {
 279     if (e.mods.isPopupMenu())
 280     {
 281         PopupMenu m;
 282
 283         m.addCommandItem (commandManager, CommandIDs::editCompLayout);
 284         m.addCommandItem (commandManager, CommandIDs::editCompGraphics);
 285         m.addSeparator();
 286
 287         for (int i = 0; i < ObjectTypes::numComponentTypes; ++i)
 288             m.addCommandItem (commandManager, CommandIDs::newComponentBase + i);
 289
 290         m.show();
 291     }
 292     else
 293     {
 294         addChildComponent (&lassoComp);
 295         lassoComp.beginLasso (e, this);
 296     }
 297 }
 298
 299 void ComponentLayoutEditor::mouseDrag (const MouseEvent& e)
 300 {
 301     lassoComp.toFront (false);
 302     lassoComp.dragLasso (e);
 303 }
 304
 305 void ComponentLayoutEditor::mouseUp (const MouseEvent& e)
 306 {
 307     lassoComp.endLasso();
 308     removeChildComponent (&lassoComp);
 309
 310     if (e.mouseWasClicked() && ! e.mods.isAnyModifierKeyDown())
 311         layout.getSelectedSet().deselectAll();
 312 }
 313
 314 static void moveOrStretch (ComponentLayout& layout, int x, int y, bool snap, bool stretch)
 315 {
 316     if (stretch)
 317         layout.stretchSelectedComps (x, y, snap);
 318     else
 319         layout.moveSelectedComps (x, y, snap);
 320 }
 321
 322 bool ComponentLayoutEditor::keyPressed (const KeyPress& key)
 323 {
 324     const bool snap = key.getModifiers().isAltDown();
 325     const bool stretch = key.getModifiers().isShiftDown();
 326
 327     const int amount = snap ? document.getSnappingGridSize() + 1
 328                             : 1;
 329
 330     if (key.isKeyCode (KeyPress::rightKey))
 331     {
 332         moveOrStretch (layout, amount, 0, snap, stretch);
 333     }
 334     else if (key.isKeyCode (KeyPress::downKey))
 335     {
 336         moveOrStretch (layout, 0,amount, snap, stretch);
 337     }
 338     else if (key.isKeyCode (KeyPress::leftKey))
 339     {
 340         moveOrStretch (layout, -amount, 0, snap, stretch);
 341     }
 342     else if (key.isKeyCode (KeyPress::upKey))
 343     {
 344         moveOrStretch (layout, 0, -amount, snap, stretch);
 345     }
 346     else
 347     {
 348         return false;
 349     }
 350
 351     return true;
 352 }
 353
 354 bool ComponentLayoutEditor::isInterestedInFileDrag (const StringArray& filenames)
 355 {
 356     const File f (filenames [0]);
 357     return f.hasFileExtension (".cpp");
 358 }
 359
 360 void ComponentLayoutEditor::filesDropped (const StringArray& filenames, int x, int y)
 361 {
 362     const File f (filenames [0]);
 363
 364     if (f.hasFileExtension (".cpp"))
 365     {
 366         JucerDocument* doc = ObjectTypes::loadDocumentFromFile (f, false);
 367
 368         if (doc != 0)
 369         {
 370             delete doc;
 371
 372             JucerComponentHandler jucerDocHandler;
 373             layout.getDocument()->getUndoManager().beginNewTransaction();
 374
 375             TestComponent* newOne
 376                 = dynamic_cast <TestComponent*> (layout.addNewComponent (&jucerDocHandler,
 377                                                                          x - subCompHolder->getX(),
 378                                                                          y - subCompHolder->getY()));
 379
 380             if (newOne != 0)
 381             {
 382                 JucerComponentHandler::setJucerComponentFile (*layout.getDocument(), newOne, f.getRelativePathFrom (document.getFile().getParentDirectory()));
 383
 384                 layout.getSelectedSet().selectOnly (newOne);
 385             }
 386
 387             layout.getDocument()->getUndoManager().beginNewTransaction();
 388         }
 389     }
 390 }
 391
 392 ComponentOverlayComponent* ComponentLayoutEditor::getOverlayCompFor (Component* compToFind) const
 393 {
 394     for (int i = getNumChildComponents(); --i >= 0;)
 395     {
 396         ComponentOverlayComponent* const overlay = dynamic_cast <ComponentOverlayComponent*> (getChildComponent (i));
 397
 398         if (overlay != 0 && overlay->target == compToFind)
 399             return overlay;
 400     }
 401
 402     return 0;
 403 }
 404
 405 void ComponentLayoutEditor::findLassoItemsInArea (Array <Component*>& results, const Rectangle<int>& area)
 406 {
 407     const Rectangle<int> lasso (area - subCompHolder->getPosition());
 408
 409     for (int i = 0; i < subCompHolder->getNumChildComponents(); ++i)
 410     {
 411         Component* c = subCompHolder->getChildComponent (i);
 412
 413         if (c->getBounds().intersects (lasso))
 414             results.add (c);
 415     }
 416 }
 417
 418 SelectedItemSet <Component*>& ComponentLayoutEditor::getLassoSelection()
 419 {
 420     return layout.getSelectedSet();
 421 }